{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preview\n",
    "\n",
    "In this example, we are going to use our toolbox to write the [PETS](https://arxiv.org/pdf/1805.12114.pdf) algorithm (Chua at al., 2018), and use it to solve a continuous version of the cartpole environment. PETS is a model-based algorithm that consists of two main components: an ensemble of probabilistic models (each a feed-forward neural network), and a planner using the [Cross-Entropy Method](https://people.smp.uq.edu.au/DirkKroese/ps/aortut.pdf) (de Boer et al., 2004). \n",
    "\n",
    "A basic implementation of this algorithm consists of the following sequence of steps:\n",
    "\n",
    "1. Gather data using an exploration policy\n",
    "2. Repeat:<br>\n",
    "  2.1. Train the dynamics model using all available data.<br>\n",
    "  2.2. Do a trajectory on the environment, choosing actions with the planner, using the dynamics model to simulate environment transitions.\n",
    "  \n",
    "The ensemble model is trained to predict the environment's dynamics, and the planner tries to find high-reward trajectories over the model dynamics. \n",
    "\n",
    "To implement this using `MBRL-Lib`, we will use an ensemble of neural networks (NNs) modelling Gaussian distributions (available in the [mbrl.models](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.GaussianMLP) module), and a trajectory optimizer agent that uses CEM (available in the [mbrl.planning](https://luisenp.github.io/mbrl-lib/planning.html#mbrl.planning.TrajectoryOptimizerAgent) module). We will also rely on several of the utilities available in the [mbrl.util](https://luisenp.github.io/mbrl-lib/util.html) module. Finally, we will wrap the dynamics model into a [gym-like environment](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.ModelEnv) over which we can plan action sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import omegaconf\n",
    "\n",
    "import mbrl.env.cartpole_continuous as cartpole_env\n",
    "import mbrl.env.reward_fns as reward_fns\n",
    "import mbrl.env.termination_fns as termination_fns\n",
    "import mbrl.models as models\n",
    "import mbrl.planning as planning\n",
    "import mbrl.util.common as common_util\n",
    "import mbrl.util as util\n",
    "\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "mpl.rcParams.update({\"font.size\": 16})\n",
    "\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the environment\n",
    "\n",
    "First we instantiate the environment and specify which reward function and termination function to use with the gym-like environment wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 0\n",
    "env = cartpole_env.CartPoleEnv()\n",
    "env.seed(seed)\n",
    "rng = np.random.default_rng(seed=0)\n",
    "generator = torch.Generator(device=device)\n",
    "generator.manual_seed(seed)\n",
    "obs_shape = env.observation_space.shape\n",
    "act_shape = env.action_space.shape\n",
    "\n",
    "# This functions allows the model to evaluate the true rewards given an observation \n",
    "reward_fn = reward_fns.cartpole\n",
    "# This function allows the model to know if an observation should make the episode end\n",
    "term_fn = termination_fns.cartpole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hydra configuration\n",
    "\n",
    "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "trial_length = 200\n",
    "num_trials = 10\n",
    "ensemble_size = 5\n",
    "\n",
    "# Everything with \"???\" indicates an option with a missing value.\n",
    "# Our utility functions will fill in these details using the \n",
    "# environment information\n",
    "cfg_dict = {\n",
    "    # dynamics model configuration\n",
    "    \"dynamics_model\": {\n",
    "        \"model\": {\n",
    "            \"_target_\": \"mbrl.models.GaussianMLP\",\n",
    "            \"device\": device,\n",
    "            \"num_layers\": 3,\n",
    "            \"ensemble_size\": ensemble_size,\n",
    "            \"hid_size\": 200,\n",
    "            \"use_silu\": True,\n",
    "            \"in_size\": \"???\",\n",
    "            \"out_size\": \"???\",\n",
    "            \"deterministic\": False,\n",
    "            \"propagation_method\": \"fixed_model\"\n",
    "        }\n",
    "    },\n",
    "    # options for training the dynamics model\n",
    "    \"algorithm\": {\n",
    "        \"learned_rewards\": False,\n",
    "        \"target_is_delta\": True,\n",
    "        \"normalize\": True,\n",
    "    },\n",
    "    # these are experiment specific options\n",
    "    \"overrides\": {\n",
    "        \"trial_length\": trial_length,\n",
    "        \"num_steps\": num_trials * trial_length,\n",
    "        \"model_batch_size\": 32,\n",
    "        \"validation_ratio\": 0.05\n",
    "    }\n",
    "}\n",
    "cfg = omegaconf.OmegaConf.create(cfg_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>Note: </b> This example uses a probabilistic ensemble. You can also use a fully deterministic model with class GaussianMLP by setting ensemble_size=1, and deterministic=True. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a dynamics model\n",
    "\n",
    "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 1-D dynamics model for this environment\n",
    "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n",
    "\n",
    "# Create a gym-like environment to encapsulate the model\n",
    "model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a replay buffer\n",
    "\n",
    "We can create a replay buffer for this environment an configuration using the following method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_buffer = common_util.create_replay_buffer(cfg, obs_shape, act_shape, rng=rng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now populate the replay buffer with random trajectories of a desired length, using a single function call to `util.rollout_agent_trajectories`. Note that we pass an agent of type `planning.RandomAgent` to generate the actions; however, this method accepts any agent that is a subclass of `planning.Agent`, allowing changing exploration strategies with minimal changes to the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# samples stored 200\n"
     ]
    }
   ],
   "source": [
    "common_util.rollout_agent_trajectories(\n",
    "    env,\n",
    "    trial_length, # initial exploration steps\n",
    "    planning.RandomAgent(env),\n",
    "    {}, # keyword arguments to pass to agent.act()\n",
    "    replay_buffer=replay_buffer,\n",
    "    trial_length=trial_length\n",
    ")\n",
    "\n",
    "print(\"# samples stored\", replay_buffer.num_stored)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CEM Agent\n",
    "\n",
    "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_cfg = omegaconf.OmegaConf.create({\n",
    "    # this class evaluates many trajectories and picks the best one\n",
    "    \"_target_\": \"mbrl.planning.TrajectoryOptimizerAgent\",\n",
    "    \"planning_horizon\": 15,\n",
    "    \"replan_freq\": 1,\n",
    "    \"verbose\": False,\n",
    "    \"action_lb\": \"???\",\n",
    "    \"action_ub\": \"???\",\n",
    "    # this is the optimizer to generate and choose a trajectory\n",
    "    \"optimizer_cfg\": {\n",
    "        \"_target_\": \"mbrl.planning.CEMOptimizer\",\n",
    "        \"num_iterations\": 5,\n",
    "        \"elite_ratio\": 0.1,\n",
    "        \"population_size\": 500,\n",
    "        \"alpha\": 0.1,\n",
    "        \"device\": device,\n",
    "        \"lower_bound\": \"???\",\n",
    "        \"upper_bound\": \"???\",\n",
    "        \"return_mean_elites\": True\n",
    "    }\n",
    "})\n",
    "\n",
    "agent = planning.create_trajectory_optim_agent_for_model(\n",
    "    model_env,\n",
    "    agent_cfg,\n",
    "    num_particles=20\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running PETS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having a model and an agent, we can now run PETS with a simple loop and a few function calls. The first code block creates a callback to pass to the model trainer to accumulate the training losses and validation scores observed. The second block is just a utility function to update the agent's visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses = []\n",
    "val_scores = []\n",
    "\n",
    "def train_callback(_model, _total_calls, _epoch, tr_loss, val_score, _best_val):\n",
    "    train_losses.append(tr_loss)\n",
    "    val_scores.append(val_score.mean().item())   # this returns val score per ensemble model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_axes(_axs, _frame, _text, _trial, _steps_trial, _all_rewards, force_update=False):\n",
    "    if not force_update and (_steps_trial % 10 != 0):\n",
    "        return\n",
    "    _axs[0].imshow(_frame)\n",
    "    _axs[0].set_xticks([])\n",
    "    _axs[0].set_yticks([])\n",
    "    _axs[1].clear()\n",
    "    _axs[1].set_xlim([0, num_trials + .1])\n",
    "    _axs[1].set_ylim([0, 200])\n",
    "    _axs[1].set_xlabel(\"Trial\")\n",
    "    _axs[1].set_ylabel(\"Trial reward\")\n",
    "    _axs[1].plot(_all_rewards, 'bs-')\n",
    "    _text.set_text(f\"Trial {_trial + 1}: {_steps_trial} steps\")\n",
    "    display.display(plt.gcf())  \n",
    "    display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following lines implement the PETS algorithm. First, we create a model trainer and pass some hyperparameters for the optimizer (Adam), along with references to the model instance to use. Then we start a loop where we execute actions of ``agent`` in the environment and train the model at the beginning of the episode (by calling ``model_trainer.train()``. At every step in the loop, we execute an agent action in the environment and populate the replay buffer by calling ``util.step_env_and_add_to_buffer()``. Importantly, at the beginning of each episode we also call ``agent.reset()`` to clear any episode dependent cache; in the case of a ``TrajectoryOptimizerAgent``, this means clearing the previous action sequence found, which is shifted at every call to obtain an initial solution for the optimizer. \n",
    "\n",
    "The rest of the code is mostly bookkeeping to keep track of the total reward observed during each episode, and to make sure episodes terminate after some desired length. After running this code, you should see the agent reaching the maximum reward of 200 after a few episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x270 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a trainer for the model\n",
    "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-3, weight_decay=5e-5)\n",
    "\n",
    "# Create visualization objects\n",
    "fig, axs = plt.subplots(1, 2, figsize=(14, 3.75), gridspec_kw={\"width_ratios\": [1, 1]})\n",
    "ax_text = axs[0].text(300, 50, \"\")\n",
    "    \n",
    "# Main PETS loop\n",
    "all_rewards = [0]\n",
    "for trial in range(num_trials):\n",
    "    obs = env.reset()    \n",
    "    agent.reset()\n",
    "    \n",
    "    done = False\n",
    "    total_reward = 0.0\n",
    "    steps_trial = 0\n",
    "    update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n",
    "    while not done:\n",
    "        # --------------- Model Training -----------------\n",
    "        if steps_trial == 0:\n",
    "            dynamics_model.update_normalizer(replay_buffer.get_all())  # update normalizer stats\n",
    "            \n",
    "            dataset_train, dataset_val = common_util.get_basic_buffer_iterators(\n",
    "                replay_buffer,\n",
    "                batch_size=cfg.overrides.model_batch_size,\n",
    "                val_ratio=cfg.overrides.validation_ratio,\n",
    "                ensemble_size=ensemble_size,\n",
    "                shuffle_each_epoch=True,\n",
    "                bootstrap_permutes=False,  # build bootstrap dataset using sampling with replacement\n",
    "            )\n",
    "                \n",
    "            model_trainer.train(\n",
    "                dataset_train, \n",
    "                dataset_val=dataset_val, \n",
    "                num_epochs=50, \n",
    "                patience=50, \n",
    "                callback=train_callback)\n",
    "\n",
    "        # --- Doing env step using the agent and adding to model dataset ---\n",
    "        next_obs, reward, done, _ = common_util.step_env_and_add_to_buffer(\n",
    "            env, obs, agent, {}, replay_buffer)\n",
    "            \n",
    "        update_axes(\n",
    "            axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n",
    "        \n",
    "        obs = next_obs\n",
    "        total_reward += reward\n",
    "        steps_trial += 1\n",
    "        \n",
    "        if steps_trial == trial_length:\n",
    "            break\n",
    "    \n",
    "    all_rewards.append(total_reward)\n",
    "\n",
    "update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards, force_update=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, below we check the results of the trainer callback, which show the training loss and validation score across all calls to ``model_trainer.train()``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 1, figsize=(12, 10))\n",
    "ax[0].plot(train_losses)\n",
    "ax[0].set_xlabel(\"Total training epochs\")\n",
    "ax[0].set_ylabel(\"Training loss (avg. NLL)\")\n",
    "ax[1].plot(val_scores)\n",
    "ax[1].set_xlabel(\"Total training epochs\")\n",
    "ax[1].set_ylabel(\"Validation score (avg. MSE)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Where to learn more about MBRL?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn about the other features of the library, please check out our [documentation](https://luisenp.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/facebookresearch/mbrl-lib/blob/master/mbrl/algorithms/pets.py) and [MBPO](https://github.com/facebookresearch/mbrl-lib/blob/master/mbrl/algorithms/mbpo.py), and their configuration [files](https://github.com/facebookresearch/mbrl-lib/tree/master/mbrl/examples/conf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mbrl",
   "language": "python",
   "name": "mbrl"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}